/**
 * 项目数据转换工具
 * 将后端API返回的数据转换为前端组件需要的格式
 */

import { enhanceProjectData, enhanceSingleProjectData } from './dataEnhancer';

/**
 * 转换项目状态
 * @param {string} status - 后端状态值
 * @returns {string} - 前端显示状态
 */
export const transformProjectStatus = (status) => {
  const statusMap = {
    'draft': '未验收',
    'in_progress': '验收中',
    'pending_invoice': '待开票',
    'invoicing': '开票中',
    'pending_payment': '待回款',
    'completed': '已回款',
    'cancelled': '已取消',
    'suspended': '已暂停'
  };
  return statusMap[status] || status;
};

/**
 * 转换项目类型
 * @param {string} projectType - 后端项目类型
 * @returns {string} - 前端显示类型
 */
export const transformProjectType = (projectType) => {
  const typeMap = {
    '1': '人力项目',
    '2': '整包项目',
    '3': '分包项目',
    'manpower': '人力项目',
    'turnkey': '整包项目',
    'subcontract': '分包项目'
  };
  return typeMap[projectType] || projectType;
};

/**
 * 计算项目进度
 * @param {Object} project - 项目数据
 * @returns {number} - 进度百分比
 */
export const calculateProjectProgress = (project) => {
  // 这里可以根据实际业务逻辑计算进度
  // 暂时返回一个默认值，实际应该根据项目状态、完成的任务数等计算
  const statusProgressMap = {
    'draft': 0,
    'in_progress': 50,
    'pending_invoice': 80,
    'invoicing': 90,
    'pending_payment': 95,
    'completed': 100,
    'cancelled': 0,
    'suspended': 30
  };
  return statusProgressMap[project.status] || 0;
};

/**
 * 格式化日期
 * @param {string} dateString - 日期字符串
 * @returns {string} - 格式化后的日期
 */
export const formatDate = (dateString) => {
  if (!dateString) return '';
  const date = new Date(dateString);
  return date.toLocaleDateString('zh-CN', {
    year: 'numeric',
    month: '2-digit',
    day: '2-digit'
  }).replace(/\//g, '.');
};

/**
 * 将后端项目数据转换为前端卡片数据格式
 * @param {Object} projectData - 后端返回的项目数据
 * @returns {Object} - 前端卡片需要的数据格式
 */
export const transformProjectForCard = (projectData) => {
  return {
    id: projectData.id,
    code: projectData.projectCode,
    project_name: projectData.projectName,
    description: projectData.description || projectData.projectSubname || '',
    status: transformProjectStatus(projectData.status),
    type: transformProjectType(projectData.projectType),
    manager: projectData.managerName || '未分配',
    createDate: formatDate(projectData.createdAt),
    deadline: formatDate(projectData.endDate),
    progress: calculateProjectProgress(projectData),
    
    // 项目立项相关数据
    totalTasks: 0, // 需要从其他接口获取
    completedTasks: 0, // 需要从其他接口获取
    pendingTasks: 0, // 需要从其他接口获取
    completionRate: calculateProjectProgress(projectData),
    
    // 项目成员相关数据
    totalMembers: 0, // 需要从成员接口获取
    activeMembers: 0, // 需要从成员接口获取
    inactiveMembers: 0, // 需要从成员接口获取
    memberRatio: 0, // 需要从成员接口获取
    
    // 项目结算相关数据
    budget: projectData.projectBudget || 0,
    estimatedCost: projectData.estimatedCost || 0,
    customerName: projectData.customerName || '',
    contractCompanyName: projectData.contractCompanyName || '',
    
    // 原始数据保留
    originalData: projectData
  };
};

/**
 * 异步转换项目数据（包含关联信息）
 * @param {Object} projectData - 后端返回的项目数据
 * @returns {Promise<Object>} - 前端卡片需要的数据格式
 */
export const transformProjectForCardAsync = async (projectData) => {
  // 先增强数据，获取关联信息
  const enhancedData = await enhanceSingleProjectData(projectData);
  
  return {
    id: enhancedData.id,
    code: enhancedData.projectCode,
    project_name: enhancedData.projectName,
    description: enhancedData.description || enhancedData.projectSubname || '',
    status: transformProjectStatus(enhancedData.status),
    type: transformProjectType(enhancedData.projectType),
    manager: enhancedData.managerName || '未分配',
    director: enhancedData.directorName || '未分配',
    createDate: formatDate(enhancedData.createdAt),
    deadline: formatDate(enhancedData.endDate),
    progress: calculateProjectProgress(enhancedData),
    
    // 项目立项相关数据
    totalTasks: 0, // 需要从其他接口获取
    completedTasks: 0, // 需要从其他接口获取
    pendingTasks: 0, // 需要从其他接口获取
    completionRate: calculateProjectProgress(enhancedData),
    
    // 项目成员相关数据
    totalMembers: 0, // 需要从成员接口获取
    activeMembers: 0, // 需要从成员接口获取
    inactiveMembers: 0, // 需要从成员接口获取
    memberRatio: 0, // 需要从成员接口获取
    
    // 项目结算相关数据
    budget: enhancedData.projectBudget || 0,
    estimatedCost: enhancedData.estimatedCost || 0,
    customerName: enhancedData.customerName || '',
    contractCompanyName: enhancedData.contractCompanyName || '',
    
    // 原始数据保留
    originalData: enhancedData
  };
};

/**
 * 批量转换项目数据
 * @param {Array} projectsData - 后端返回的项目数据数组
 * @returns {Array} - 转换后的项目数据数组
 */
export const transformProjectsForCards = (projectsData) => {
  if (!Array.isArray(projectsData)) {
    return [];
  }
  return projectsData.map(transformProjectForCard);
};

/**
 * 异步批量转换项目数据（包含关联信息）
 * @param {Array} projectsData - 后端返回的项目数据数组
 * @returns {Promise<Array>} - 转换后的项目数据数组
 */
export const transformProjectsForCardsAsync = async (projectsData) => {
  if (!Array.isArray(projectsData)) {
    return [];
  }
  
  // 先增强数据，获取关联信息
  const enhancedProjects = await enhanceProjectData(projectsData);
  
  // 然后转换数据格式
  return enhancedProjects.map(transformProjectForCard);
};

/**
 * 获取状态颜色
 * @param {string} status - 项目状态
 * @returns {string} - 颜色值
 */
export const getStatusColor = (status) => {
  const colors = {
    '未验收': 'blue',
    '验收中': 'orange',
    '待开票': 'purple',
    '开票中': 'magenta',
    '待回款': 'volcano',
    '已回款': 'green',
    '已取消': 'default',
    '已暂停': 'warning'
  };
  return colors[status] || 'default';
};

/**
 * 获取项目类型颜色
 * @param {string} type - 项目类型
 * @returns {string} - 颜色值
 */
export const getTypeColor = (type) => {
  const colors = {
    '人力项目': 'cyan',
    '整包项目': 'geekblue',
    '分包项目': 'purple'
  };
  return colors[type] || 'default';
};

/**
 * 转换项目卡片数据（新的API返回格式）
 * @param {Object} cardData - 后端返回的项目卡片数据
 * @returns {Object} - 前端卡片需要的数据格式
 */
export const transformProjectCardForDisplay = (cardData) => {
  return {
    id: cardData.projectCode, // 使用项目编号作为唯一标识
    code: cardData.projectCode,
    project_name: cardData.projectName,
    description: cardData.projectSubname || '',
    status: cardData.projectStatus,
    type: cardData.projectTypeName || transformProjectType(cardData.projectType),
    manager: cardData.managerName || '未分配',
    createDate: formatDate(cardData.startDate),
    deadline: formatDate(cardData.endDate),
    
    // 任务统计信息（验收单统计）
    totalTasks: cardData.totalTasks || 0,
    completedTasks: cardData.completedTasks || 0,
    pendingTasks: cardData.pendingTasks || 0,
    completionRate: cardData.totalTasks > 0 ? 
      Math.round((cardData.completedTasks / cardData.totalTasks) * 100) : 0,
    
    // 项目基本信息
    budget: 0, // 项目卡片API暂不返回预算信息
    estimatedCost: 0,
    customerName: cardData.customerName || '',
    contractCompanyName: cardData.contractCompanyName || '',
    
    // 原始数据保留
    originalData: cardData
  };
};

/**
 * 批量转换项目卡片数据
 * @param {Array} cardsData - 后端返回的项目卡片数据数组
 * @returns {Array} - 转换后的项目卡片数据数组
 */
export const transformProjectCardsForDisplay = (cardsData) => {
  if (!Array.isArray(cardsData)) {
    return [];
  }
  return cardsData.map(transformProjectCardForDisplay);
};

/**
 * 获取项目卡片状态颜色（基于验收单状态）
 * @param {string} status - 项目状态
 * @returns {string} - 颜色值
 */
export const getProjectCardStatusColor = (status) => {
  const colors = {
    '未开始': 'default',
    '进行中': 'processing',
    '已验收': 'success',
    '验收失败': 'error'
  };
  return colors[status] || 'default';
};